home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2004 #2 / K-CD-2-2004.ISO / OpenOffice Sv / f_0397 / python-core-2.2.2 / lib / test / test_re.py < prev    next >
Encoding:
Python Source  |  2003-07-18  |  12.5 KB  |  393 lines
  1. import sys
  2. sys.path = ['.'] + sys.path
  3.  
  4. from test_support import verify, verbose, TestFailed
  5. import re
  6. import sys, os, traceback
  7.  
  8. # Misc tests from Tim Peters' re.doc
  9.  
  10. if verbose:
  11.     print 'Running tests on re.search and re.match'
  12.  
  13. try:
  14.     verify(re.search('x*', 'axx').span(0) == (0, 0))
  15.     verify(re.search('x*', 'axx').span() == (0, 0))
  16.     verify(re.search('x+', 'axx').span(0) == (1, 3))
  17.     verify(re.search('x+', 'axx').span() == (1, 3))
  18.     verify(re.search('x', 'aaa') is None)
  19. except:
  20.     raise TestFailed, "re.search"
  21.  
  22. try:
  23.     verify(re.match('a*', 'xxx').span(0) == (0, 0))
  24.     verify(re.match('a*', 'xxx').span() == (0, 0))
  25.     verify(re.match('x*', 'xxxa').span(0) == (0, 3))
  26.     verify(re.match('x*', 'xxxa').span() == (0, 3))
  27.     verify(re.match('a+', 'xxx') is None)
  28. except:
  29.     raise TestFailed, "re.search"
  30.  
  31. if verbose:
  32.     print 'Running tests on re.sub'
  33.  
  34. try:
  35.     verify(re.sub("(?i)b+", "x", "bbbb BBBB") == 'x x')
  36.  
  37.     def bump_num(matchobj):
  38.         int_value = int(matchobj.group(0))
  39.         return str(int_value + 1)
  40.  
  41.     verify(re.sub(r'\d+', bump_num, '08.2 -2 23x99y') == '9.3 -3 24x100y')
  42.     verify(re.sub(r'\d+', bump_num, '08.2 -2 23x99y', 3) == '9.3 -3 23x99y')
  43.  
  44.     verify(re.sub('.', lambda m: r"\n", 'x') == '\\n')
  45.     verify(re.sub('.', r"\n", 'x') == '\n')
  46.  
  47.     s = r"\1\1"
  48.     verify(re.sub('(.)', s, 'x') == 'xx')
  49.     verify(re.sub('(.)', re.escape(s), 'x') == s)
  50.     verify(re.sub('(.)', lambda m: s, 'x') == s)
  51.  
  52.     verify(re.sub('(?P<a>x)', '\g<a>\g<a>', 'xx') == 'xxxx')
  53.     verify(re.sub('(?P<a>x)', '\g<a>\g<1>', 'xx') == 'xxxx')
  54.     verify(re.sub('(?P<unk>x)', '\g<unk>\g<unk>', 'xx') == 'xxxx')
  55.     verify(re.sub('(?P<unk>x)', '\g<1>\g<1>', 'xx') == 'xxxx')
  56.  
  57.     verify(re.sub('a', r'\t\n\v\r\f\a\b\B\Z\a\A\w\W\s\S\d\D', 'a') == '\t\n\v\r\f\a\b\\B\\Z\a\\A\\w\\W\\s\\S\\d\\D')
  58.     verify(re.sub('a', '\t\n\v\r\f\a', 'a') == '\t\n\v\r\f\a')
  59.     verify(re.sub('a', '\t\n\v\r\f\a', 'a') == (chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)))
  60.  
  61.     verify(re.sub('^\s*', 'X', 'test') == 'Xtest')
  62.  
  63.     # Test for sub() on escaped characters, see SF bug #449000
  64.     verify(re.sub(r'\r\n', r'\n', 'abc\r\ndef\r\n') == 'abc\ndef\n')
  65.     verify(re.sub('\r\n', r'\n', 'abc\r\ndef\r\n') == 'abc\ndef\n')
  66.     verify(re.sub(r'\r\n', '\n', 'abc\r\ndef\r\n') == 'abc\ndef\n')
  67.     verify(re.sub('\r\n', '\n', 'abc\r\ndef\r\n') == 'abc\ndef\n')
  68. except AssertionError:
  69.     raise TestFailed, "re.sub"
  70.  
  71.  
  72. try:
  73.     verify(re.sub('a', 'b', 'aaaaa') == 'bbbbb')
  74.     verify(re.sub('a', 'b', 'aaaaa', 1) == 'baaaa')
  75. except AssertionError:
  76.     raise TestFailed, "qualified re.sub"
  77.  
  78. if verbose:
  79.     print 'Running tests on symbolic references'
  80.  
  81. try:
  82.     re.sub('(?P<a>x)', '\g<a', 'xx')
  83. except re.error, reason:
  84.     pass
  85. else:
  86.     raise TestFailed, "symbolic reference"
  87.  
  88. try:
  89.     re.sub('(?P<a>x)', '\g<', 'xx')
  90. except re.error, reason:
  91.     pass
  92. else:
  93.     raise TestFailed, "symbolic reference"
  94.  
  95. try:
  96.     re.sub('(?P<a>x)', '\g', 'xx')
  97. except re.error, reason:
  98.     pass
  99. else:
  100.     raise TestFailed, "symbolic reference"
  101.  
  102. try:
  103.     re.sub('(?P<a>x)', '\g<a a>', 'xx')
  104. except re.error, reason:
  105.     pass
  106. else:
  107.     raise TestFailed, "symbolic reference"
  108.  
  109. try:
  110.     re.sub('(?P<a>x)', '\g<1a1>', 'xx')
  111. except re.error, reason:
  112.     pass
  113. else:
  114.     raise TestFailed, "symbolic reference"
  115.  
  116. try:
  117.     re.sub('(?P<a>x)', '\g<ab>', 'xx')
  118. except IndexError, reason:
  119.     pass
  120. else:
  121.     raise TestFailed, "symbolic reference"
  122.  
  123. try:
  124.     re.sub('(?P<a>x)|(?P<b>y)', '\g<b>', 'xx')
  125. except re.error, reason:
  126.     pass
  127. else:
  128.     raise TestFailed, "symbolic reference"
  129.  
  130. try:
  131.     re.sub('(?P<a>x)|(?P<b>y)', '\\2', 'xx')
  132. except re.error, reason:
  133.     pass
  134. else:
  135.     raise TestFailed, "symbolic reference"
  136.  
  137. if verbose:
  138.     print 'Running tests on re.subn'
  139.  
  140. try:
  141.     verify(re.subn("(?i)b+", "x", "bbbb BBBB") == ('x x', 2))
  142.     verify(re.subn("b+", "x", "bbbb BBBB") == ('x BBBB', 1))
  143.     verify(re.subn("b+", "x", "xyz") == ('xyz', 0))
  144.     verify(re.subn("b*", "x", "xyz") == ('xxxyxzx', 4))
  145.     verify(re.subn("b*", "x", "xyz", 2) == ('xxxyz', 2))
  146. except AssertionError:
  147.     raise TestFailed, "re.subn"
  148.  
  149. if verbose:
  150.     print 'Running tests on re.split'
  151.  
  152. try:
  153.     verify(re.split(":", ":a:b::c") == ['', 'a', 'b', '', 'c'])
  154.     verify(re.split(":*", ":a:b::c") == ['', 'a', 'b', 'c'])
  155.     verify(re.split("(:*)", ":a:b::c") == ['', ':', 'a', ':', 'b', '::', 'c'])
  156.     verify(re.split("(?::*)", ":a:b::c") == ['', 'a', 'b', 'c'])
  157.     verify(re.split("(:)*", ":a:b::c") == ['', ':', 'a', ':', 'b', ':', 'c'])
  158.     verify(re.split("([b:]+)", ":a:b::c") == ['', ':', 'a', ':b::', 'c'])
  159.     verify(re.split("(b)|(:+)", ":a:b::c") == \
  160.            ['', None, ':', 'a', None, ':', '', 'b', None, '', None, '::', 'c'] )
  161.     verify(re.split("(?:b)|(?::+)", ":a:b::c") == ['', 'a', '', '', 'c'])
  162. except AssertionError:
  163.     raise TestFailed, "re.split"
  164.  
  165. try:
  166.     verify(re.split(":", ":a:b::c", 2) == ['', 'a', 'b::c'])
  167.     verify(re.split(':', 'a:b:c:d', 2) == ['a', 'b', 'c:d'])
  168.  
  169.     verify(re.split("(:)", ":a:b::c", 2) == ['', ':', 'a', ':', 'b::c'])
  170.     verify(re.split("(:*)", ":a:b::c", 2) == ['', ':', 'a', ':', 'b::c'])
  171. except AssertionError:
  172.     raise TestFailed, "qualified re.split"
  173.  
  174. if verbose:
  175.     print "Running tests on re.findall"
  176.  
  177. try:
  178.     verify(re.findall(":+", "abc") == [])
  179.     verify(re.findall(":+", "a:b::c:::d") == [":", "::", ":::"])
  180.     verify(re.findall("(:+)", "a:b::c:::d") == [":", "::", ":::"])
  181.     verify(re.findall("(:)(:*)", "a:b::c:::d") == [(":", ""),
  182.                                                    (":", ":"),
  183.                                                    (":", "::")] )
  184. except AssertionError:
  185.     raise TestFailed, "re.findall"
  186.  
  187. if verbose:
  188.     print "Running tests on re.match"
  189.  
  190. try:
  191.     # No groups at all
  192.     m = re.match('a', 'a') ; verify(m.groups() == ())
  193.     # A single group
  194.     m = re.match('(a)', 'a') ; verify(m.groups() == ('a',))
  195.  
  196.     pat = re.compile('((a)|(b))(c)?')
  197.     verify(pat.match('a').groups() == ('a', 'a', None, None))
  198.     verify(pat.match('b').groups() == ('b', None, 'b', None))
  199.     verify(pat.match('ac').groups() == ('a', 'a', None, 'c'))
  200.     verify(pat.match('bc').groups() == ('b', None, 'b', 'c'))
  201.     verify(pat.match('bc').groups("") == ('b', "", 'b', 'c'))
  202. except AssertionError:
  203.     raise TestFailed, "match .groups() method"
  204.  
  205. try:
  206.     # A single group
  207.     m = re.match('(a)', 'a')
  208.     verify(m.group(0) == 'a')
  209.     verify(m.group(0) == 'a')
  210.     verify(m.group(1) == 'a')
  211.     verify(m.group(1, 1) == ('a', 'a'))
  212.  
  213.     pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
  214.     verify(pat.match('a').group(1, 2, 3) == ('a', None, None))
  215.     verify(pat.match('b').group('a1', 'b2', 'c3') == (None, 'b', None))
  216.     verify(pat.match('ac').group(1, 'b2', 3) == ('a', None, 'c'))
  217. except AssertionError:
  218.     raise TestFailed, "match .group() method"
  219.  
  220. if verbose:
  221.     print "Running tests on re.escape"
  222.  
  223. try:
  224.     p=""
  225.     for i in range(0, 256):
  226.         p = p + chr(i)
  227.         verify(re.match(re.escape(chr(i)), chr(i)) is not None)
  228.         verify(re.match(re.escape(chr(i)), chr(i)).span() == (0,1))
  229.  
  230.     pat=re.compile( re.escape(p) )
  231.     verify(pat.match(p) is not None)
  232.     verify(pat.match(p).span() == (0,256))
  233. except AssertionError:
  234.     raise TestFailed, "re.escape"
  235.  
  236.  
  237. if verbose:
  238.     print 'Pickling a RegexObject instance'
  239.  
  240. import pickle
  241. pat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')
  242. s = pickle.dumps(pat)
  243. pat = pickle.loads(s)
  244.  
  245. try:
  246.     verify(re.I == re.IGNORECASE)
  247.     verify(re.L == re.LOCALE)
  248.     verify(re.M == re.MULTILINE)
  249.     verify(re.S == re.DOTALL)
  250.     verify(re.X == re.VERBOSE)
  251. except AssertionError:
  252.     raise TestFailed, 're module constants'
  253.  
  254. for flags in [re.I, re.M, re.X, re.S, re.L]:
  255.     try:
  256.         r = re.compile('^pattern$', flags)
  257.     except:
  258.         print 'Exception raised on flag', flags
  259.  
  260. if verbose:
  261.     print 'Test engine limitations'
  262.  
  263. # Try nasty case that overflows the straightforward recursive
  264. # implementation of repeated groups.
  265. try:
  266.     verify(re.match('(x)*', 50000*'x').span() == (0, 50000))
  267. except RuntimeError, v:
  268.     print v
  269.  
  270. from re_tests import *
  271.  
  272. if verbose:
  273.     print 'Running re_tests test suite'
  274. else:
  275.     # To save time, only run the first and last 10 tests
  276.     #tests = tests[:10] + tests[-10:]
  277.     pass
  278.  
  279. for t in tests:
  280.     sys.stdout.flush()
  281.     pattern = s = outcome = repl = expected = None
  282.     if len(t) == 5:
  283.         pattern, s, outcome, repl, expected = t
  284.     elif len(t) == 3:
  285.         pattern, s, outcome = t
  286.     else:
  287.         raise ValueError, ('Test tuples should have 3 or 5 fields', t)
  288.  
  289.     try:
  290.         obj = re.compile(pattern)
  291.     except re.error:
  292.         if outcome == SYNTAX_ERROR: pass  # Expected a syntax error
  293.         else:
  294.             print '=== Syntax error:', t
  295.     except KeyboardInterrupt: raise KeyboardInterrupt
  296.     except:
  297.         print '*** Unexpected error ***', t
  298.         if verbose:
  299.             traceback.print_exc(file=sys.stdout)
  300.     else:
  301.         try:
  302.             result = obj.search(s)
  303.         except re.error, msg:
  304.             print '=== Unexpected exception', t, repr(msg)
  305.         if outcome == SYNTAX_ERROR:
  306.             # This should have been a syntax error; forget it.
  307.             pass
  308.         elif outcome == FAIL:
  309.             if result is None: pass   # No match, as expected
  310.             else: print '=== Succeeded incorrectly', t
  311.         elif outcome == SUCCEED:
  312.             if result is not None:
  313.                 # Matched, as expected, so now we compute the
  314.                 # result string and compare it to our expected result.
  315.                 start, end = result.span(0)
  316.                 vardict={'found': result.group(0),
  317.                          'groups': result.group(),
  318.                          'flags': result.re.flags}
  319.                 for i in range(1, 100):
  320.                     try:
  321.                         gi = result.group(i)
  322.                         # Special hack because else the string concat fails:
  323.                         if gi is None:
  324.                             gi = "None"
  325.                     except IndexError:
  326.                         gi = "Error"
  327.                     vardict['g%d' % i] = gi
  328.                 for i in result.re.groupindex.keys():
  329.                     try:
  330.                         gi = result.group(i)
  331.                         if gi is None:
  332.                             gi = "None"
  333.                     except IndexError:
  334.                         gi = "Error"
  335.                     vardict[i] = gi
  336.                 repl = eval(repl, vardict)
  337.                 if repl != expected:
  338.                     print '=== grouping error', t,
  339.                     print repr(repl) + ' should be ' + repr(expected)
  340.             else:
  341.                 print '=== Failed incorrectly', t
  342.  
  343.             # Try the match on a unicode string, and check that it
  344.             # still succeeds.
  345.             try:
  346.                 result = obj.search(unicode(s, "latin-1"))
  347.                 if result is None:
  348.                     print '=== Fails on unicode match', t
  349.             except NameError:
  350.                 continue # 1.5.2
  351.             except TypeError:
  352.                 continue # unicode test case
  353.  
  354.             # Try the match on a unicode pattern, and check that it
  355.             # still succeeds.
  356.             obj=re.compile(unicode(pattern, "latin-1"))
  357.             result = obj.search(s)
  358.             if result is None:
  359.                 print '=== Fails on unicode pattern match', t
  360.  
  361.             # Try the match with the search area limited to the extent
  362.             # of the match and see if it still succeeds.  \B will
  363.             # break (because it won't match at the end or start of a
  364.             # string), so we'll ignore patterns that feature it.
  365.  
  366.             if pattern[:2] != '\\B' and pattern[-2:] != '\\B' \
  367.                            and result is not None:
  368.                 obj = re.compile(pattern)
  369.                 result = obj.search(s, result.start(0), result.end(0) + 1)
  370.                 if result is None:
  371.                     print '=== Failed on range-limited match', t
  372.  
  373.             # Try the match with IGNORECASE enabled, and check that it
  374.             # still succeeds.
  375.             obj = re.compile(pattern, re.IGNORECASE)
  376.             result = obj.search(s)
  377.             if result is None:
  378.                 print '=== Fails on case-insensitive match', t
  379.  
  380.             # Try the match with LOCALE enabled, and check that it
  381.             # still succeeds.
  382.             obj = re.compile(pattern, re.LOCALE)
  383.             result = obj.search(s)
  384.             if result is None:
  385.                 print '=== Fails on locale-sensitive match', t
  386.  
  387.             # Try the match with UNICODE locale enabled, and check
  388.             # that it still succeeds.
  389.             obj = re.compile(pattern, re.UNICODE)
  390.             result = obj.search(s)
  391.             if result is None:
  392.                 print '=== Fails on unicode-sensitive match', t
  393.